
// AI聊天功能初始化
function initAIChat() {
    const chatBubble = document.getElementById('chatBubble');
    const chatWindow = document.getElementById('chatWindow');
    const chatInput = chatWindow?.querySelector('#chatInput');
    const chatButton = chatWindow?.querySelector('#chatSend');
    const chatMessages = chatWindow?.querySelector('#chatMessages');
    const chatClose = chatWindow?.querySelector('#chatClose');
    
    if (!chatBubble || !chatWindow) return;
    
    let isChatOpen = false;
    let currentConversationId = null;
    let isRestoringState = false; // 标志：是否正在从缓存恢复状态
    
    // 从localStorage恢复聊天窗口状态
    function restoreChatState() {
        try {
            isRestoringState = true; // 标记正在恢复状态
            
            const savedState = localStorage.getItem('aiChatState');
            if (savedState) {
                const state = JSON.parse(savedState);
                
                // 检查状态是否过期（24小时）
                const now = Date.now();
                const stateAge = now - (state.timestamp || 0);
                const maxAge = 24 * 60 * 60 * 1000; // 24小时
                
                if (stateAge > maxAge) {
                    console.log('[状态恢复] 状态已过期，清除旧状态');
                    localStorage.removeItem('aiChatState');
                    isRestoringState = false;
                    return;
                }
                
                isChatOpen = state.isOpen || false;
                const savedWidth = state.width || 500;
                const savedConversationId = state.conversationId || null;
                const savedConversationHtml = state.conversationHtml || '';
                
                // 设置聊天窗口宽度
                chatWindow.style.width = savedWidth + 'px';
                document.documentElement.style.setProperty('--chat-width', savedWidth + 'px');
                
                // 恢复对话ID（不需要验证，直接使用）
                if (savedConversationId) {
                    currentConversationId = savedConversationId;
                    window.currentConversationId = savedConversationId;
                    console.log('[状态恢复] 对话ID已恢复:', savedConversationId);
                }
                
                // 恢复历史记录页面标志
                if (state.isFromHistory) {
                    window.isFromHistoryPage = true;
                    console.log('[状态恢复] 历史记录页面标志已恢复');
                }
                
                // 如果之前是打开状态，恢复打开状态（无动画）
                if (isChatOpen) {
                    // 添加无动画类
                    chatWindow.classList.add('no-animation');
                    chatWindow.classList.add('open');
                    
                    const pageContainer = document.querySelector('.page-container');
                    if (pageContainer) {
                        pageContainer.classList.add('no-animation');
                        pageContainer.classList.add('chat-open');
                        // 恢复左侧功能区的宽度调整
                        pageContainer.style.marginRight = savedWidth + 'px';
                        pageContainer.style.maxWidth = `calc(100% - ${savedWidth}px)`;
                        // 同时保存到leftPanelWidth以便其他函数使用
                        localStorage.setItem('leftPanelWidth', savedWidth + 'px');
                    }
                    
                    // 强制重绘后移除无动画类
                    setTimeout(() => {
                        chatWindow.classList.remove('no-animation');
                        if (pageContainer) {
                            pageContainer.classList.remove('no-animation');
                        }
                    }, 50);
                    
                    // 从本地HTML恢复对话内容
                    if (savedConversationHtml) {
                        restoreConversationFromHtml(savedConversationHtml);
                    }
                }
                
                console.log('[状态恢复] 聊天窗口状态已恢复:', state);
            }
            
            isRestoringState = false; // 恢复完成
        } catch (error) {
            console.error('[状态恢复] 恢复状态失败:', error);
            isRestoringState = false;
        }
    }
    
    // 保存聊天窗口状态到localStorage
    function saveChatState() {
        try {
            const chatMessages = document.getElementById('chatMessages');
            let conversationHtml = '';
            
            if (chatMessages && chatMessages.children.length > 0) {
                // 获取聊天消息的HTML内容，包括"查看详情"按钮
                conversationHtml = chatMessages.innerHTML;
            }
            
            const state = {
                isOpen: isChatOpen,
                width: parseInt(chatWindow.style.width) || 500,
                conversationId: currentConversationId || window.currentConversationId,
                conversationHtml: conversationHtml,
                isFromHistory: window.isFromHistoryPage || false,
                timestamp: Date.now()
            };
            localStorage.setItem('aiChatState', JSON.stringify(state));
            
            // 如果聊天窗口打开，保存左侧功能区的宽度调整
            if (isChatOpen) {
                const pageContainer = document.querySelector('.page-container');
                if (pageContainer && pageContainer.style.marginRight) {
                    localStorage.setItem('leftPanelWidth', pageContainer.style.marginRight);
                }
            }
            
            console.log('[状态保存] 聊天窗口状态已保存:', state);
        } catch (error) {
            console.error('[状态保存] 保存状态失败:', error);
        }
    }
    
    // 初始化CSS变量
    document.documentElement.style.setProperty('--chat-width', '500px');
    
    // 从HTML恢复对话内容的函数
    function restoreConversationFromHtml(conversationHtml) {
        try {
            console.log('[本地恢复] 开始从本地HTML恢复对话内容');
            
            const chatMessages = document.getElementById('chatMessages');
            const chatTitle = document.getElementById('chatTitle');
            
            if (!chatMessages) {
                console.error('[本地恢复] 聊天消息容器未找到');
                return;
            }
            
            // 直接恢复HTML内容
            chatMessages.innerHTML = conversationHtml;
            
            // 滚动到底部
            chatMessages.scrollTop = chatMessages.scrollHeight;
            
            // 重新绑定"查看详情"按钮的事件
            rebindDetailButtons(chatMessages);
            
            console.log('[本地恢复] 对话内容恢复完成');
        } catch (error) {
            console.error('[本地恢复] 恢复对话内容时出错:', error);
            const chatMessages = document.getElementById('chatMessages');
            if (chatMessages) {
                chatMessages.innerHTML = '<div class="message ai-message">抱歉，恢复对话内容时出现错误。请重新开始对话。</div>';
            }
        }
    }
    
    // 重新绑定"查看详情"按钮事件的函数
    function rebindDetailButtons(container) {
        try {
            const detailButtons = container.querySelectorAll('.comp-ref-btn');
            detailButtons.forEach(button => {
                // 获取竞赛信息
                const competitionData = JSON.parse(button.dataset.competition || '{}');
                
                // 移除旧的事件监听器并重新绑定
                button.addEventListener('click', (e) => {
                    e.stopPropagation();
                    if (typeof window.showCompetitionDetail === 'function' && competitionData && competitionData.name) {
                        window.showCompetitionDetail(competitionData);
                    }
                });
            });
            
            console.log('[按钮重绑] 已重新绑定', detailButtons.length, '个按钮');
        } catch (error) {
            console.error('[按钮重绑] 重新绑定按钮事件时出错:', error);
        }
    }
    
    // 页面加载时恢复状态
    // 延迟恢复，确保DOM完全加载
    setTimeout(() => {
        // 先清理过大的数据
        cleanupLocalStorage();
        // 然后恢复状态
        restoreChatState();
        // 检查并恢复左侧功能区的宽度调整
        restoreLeftPanelWidth();
    }, 50);
    
    // 重置所有手动设置的样式
    function resetChatWindowStyles() {
        const pageContainer = document.querySelector('.page-container');
        if (pageContainer) {
            pageContainer.style.marginRight = '';
            pageContainer.style.maxWidth = '';
        }
        // 不重置聊天窗口宽度，保持用户设置的宽度
        // chatWindow.style.width = '';
        // document.documentElement.style.setProperty('--chat-width', '500px');
        // 清除左侧功能区宽度调整的localStorage记录
        localStorage.removeItem('leftPanelWidth');
    }
    
    // 恢复左侧功能区的宽度调整
    function restoreLeftPanelWidth() {
        try {
            const savedWidth = localStorage.getItem('leftPanelWidth');
            if (savedWidth && isChatOpen) {
                const pageContainer = document.querySelector('.page-container');
                if (pageContainer) {
                    const widthValue = parseInt(savedWidth);
                    pageContainer.style.marginRight = savedWidth;
                    pageContainer.style.maxWidth = `calc(100% - ${widthValue}px)`;
                    console.log('[左侧功能区恢复] 已恢复宽度调整:', savedWidth);
                }
            }
        } catch (error) {
            console.error('[左侧功能区恢复] 恢复宽度调整失败:', error);
        }
    }
    
    // 拖拽调整聊天窗口宽度
    let isResizing = false;
    let startX = 0;
    let startWidth = 0;
    
    // 为整个聊天窗口添加拖拽事件监听器
    chatWindow.addEventListener('mousedown', function(e) {
        // 如果正在恢复状态，不处理拖拽
        if (isRestoringState) return;
        
        // 检查是否点击在左侧拖拽区域
        if (e.offsetX <= 4) {
            isResizing = true;
            startX = e.clientX;
            startWidth = chatWindow.offsetWidth;
            document.body.style.cursor = 'ew-resize';
            chatWindow.classList.add('resizing');
            e.preventDefault();
        }
    });
    
    document.addEventListener('mousemove', function(e) {
        if (isResizing) {
            const deltaX = startX - e.clientX;
            const newWidth = Math.max(400, Math.min(800, startWidth + deltaX));
            chatWindow.style.width = newWidth + 'px';
            
            // 同步调整页面容器的右边距和最大宽度
            const pageContainer = document.querySelector('.page-container');
            if (pageContainer && isChatOpen) {
                pageContainer.style.marginRight = newWidth + 'px';
                pageContainer.style.maxWidth = `calc(100% - ${newWidth}px)`;
                // 保存左侧功能区的宽度调整到localStorage
                localStorage.setItem('leftPanelWidth', newWidth + 'px');
            }
            
            // 更新CSS变量
            document.documentElement.style.setProperty('--chat-width', newWidth + 'px');
        }
    });
    
    document.addEventListener('mouseup', function() {
        if (isResizing) {
            isResizing = false;
            document.body.style.cursor = 'default';
            chatWindow.classList.remove('resizing');
            
            // 保存当前宽度到CSS变量，用于气泡位置计算
            const currentWidth = chatWindow.offsetWidth;
            document.documentElement.style.setProperty('--chat-width', currentWidth + 'px');
            
            // 如果聊天窗口已关闭，清除手动设置的样式
            if (!isChatOpen) {
                resetChatWindowStyles();
            }
            
            // 保存状态（包括新的宽度）
            saveChatState();
        }
    });
    
    // 点击气泡打开/关闭聊天窗口
    chatBubble.addEventListener('click', function() {
        // 如果正在恢复状态，不处理点击事件
        if (isRestoringState) return;
        
        isChatOpen = !isChatOpen;
        const pageContainer = document.querySelector('.page-container');
        
        if (isChatOpen) {
            chatWindow.classList.add('open');
            if (pageContainer) {
                pageContainer.classList.add('chat-open');
                // 恢复左侧功能区的宽度调整
                const savedWidth = parseInt(chatWindow.style.width) || 500;
                pageContainer.style.marginRight = savedWidth + 'px';
                pageContainer.style.maxWidth = `calc(100% - ${savedWidth}px)`;
            }
            if (chatInput) chatInput.focus();
            
            // 检查是否是从历史记录页面触发的
            const chatMessages = document.getElementById('chatMessages');
            const isFromHistory = window.currentConversationId && chatMessages && 
                chatMessages.children.length > 1; // 如果有多个消息，说明是从历史记录打开的
            
            // 如果不是从历史记录页面触发的，清空消息准备新对话
            if (!isFromHistory) {
                // 清空聊天消息，准备新对话
                if (chatMessages) {
                    chatMessages.innerHTML = '<div class="message ai-message">您好！我是竞赛智能助手。请问有什么可以帮您？</div>';
                }
                // 清除对话ID
                currentConversationId = null;
                window.currentConversationId = null;
            }
        } else {
            chatWindow.classList.remove('open');
            if (pageContainer) {
                pageContainer.classList.remove('chat-open');
            }
            // 重置所有手动设置的样式
            resetChatWindowStyles();
            
            // 清除历史记录页面标志
            window.isFromHistoryPage = false;
        }
        
        // 保存状态
        saveChatState();
    });
    
    // 关闭聊天窗口
    if (chatClose) {
        chatClose.addEventListener('click', function() {
            // 如果正在恢复状态，不处理点击事件
            if (isRestoringState) return;
            
            isChatOpen = false;
            chatWindow.classList.remove('open');
            const pageContainer = document.querySelector('.page-container');
            if (pageContainer) {
                pageContainer.classList.remove('chat-open');
            }
            // 重置所有手动设置的样式
            resetChatWindowStyles();
            // 清除当前对话ID，下次打开时是新对话
            currentConversationId = null;
            window.currentConversationId = null;
            // 重置聊天窗口标题
            const chatTitle = document.getElementById('chatTitle');
            if (chatTitle) {
                chatTitle.textContent = 'AI竞赛助手';
            }
            // 清空聊天消息
            const chatMessages = document.getElementById('chatMessages');
            if (chatMessages) {
                chatMessages.innerHTML = '<div class="message ai-message">您好！我是竞赛智能助手。请问有什么可以帮您？</div>';
            }
            
            // 清除历史记录页面标志
            window.isFromHistoryPage = false;
            
            // 保存状态（包括清空后的HTML）
            saveChatState();
        });
    }
    
    // 暴露全局函数，供其他页面调用
    window.closeAIChat = function() {
        // 如果正在恢复状态，不处理关闭
        if (isRestoringState) return;
        
        isChatOpen = false;
        chatWindow.classList.remove('open');
        const pageContainer = document.querySelector('.page-container');
        if (pageContainer) {
            pageContainer.classList.remove('chat-open');
        }
        // 重置所有手动设置的样式
        resetChatWindowStyles();
        // 清除当前对话ID
        currentConversationId = null;
        window.currentConversationId = null;
        // 重置聊天窗口标题
        const chatTitle = document.getElementById('chatTitle');
        if (chatTitle) {
            chatTitle.textContent = 'AI竞赛助手';
        }
        // 清空聊天消息
        const chatMessages = document.getElementById('chatMessages');
        if (chatMessages) {
            chatMessages.innerHTML = '<div class="message ai-message">您好！我是竞赛智能助手。请问有什么可以帮您？</div>';
        }
        
        // 清除历史记录页面标志
        window.isFromHistoryPage = false;
        
        // 保存状态
        saveChatState();
    };
    
    // 暴露状态保存函数
    window.saveAIChatState = saveChatState;
    
    // 暴露状态恢复函数
    window.restoreAIChatState = restoreChatState;
    
    // 暴露状态清理函数
    window.clearAIChatState = function() {
        try {
            localStorage.removeItem('aiChatState');
            console.log('[状态清理] 聊天窗口状态已清除');
        } catch (error) {
            console.error('[状态清理] 清除状态失败:', error);
        }
    };
    
    // 清理过大的localStorage数据
    function cleanupLocalStorage() {
        try {
            const savedState = localStorage.getItem('aiChatState');
            if (savedState) {
                const state = JSON.parse(savedState);
                const htmlSize = (state.conversationHtml || '').length;
                
                // 如果HTML内容超过100KB，清理HTML内容但保留其他状态
                if (htmlSize > 100 * 1024) {
                    console.log('[存储清理] HTML内容过大，清理HTML内容');
                    state.conversationHtml = '';
                    state.timestamp = Date.now();
                    localStorage.setItem('aiChatState', JSON.stringify(state));
                }
            }
        } catch (error) {
            console.error('[存储清理] 清理localStorage时出错:', error);
        }
    }
    
    // 暴露恢复状态检查函数
    window.isRestoringAIChatState = function() {
        return isRestoringState;
    };
    
    // 暴露localStorage使用情况检查函数
    window.getAIChatStorageInfo = function() {
        try {
            const savedState = localStorage.getItem('aiChatState');
            if (savedState) {
                const state = JSON.parse(savedState);
                const htmlSize = (state.conversationHtml || '').length;
                const totalSize = new Blob([savedState]).size;
                
                return {
                    htmlSize: htmlSize,
                    totalSize: totalSize,
                    htmlSizeKB: (htmlSize / 1024).toFixed(2),
                    totalSizeKB: (totalSize / 1024).toFixed(2),
                    timestamp: state.timestamp,
                    isOpen: state.isOpen,
                    hasConversationId: !!state.conversationId,
                    isFromHistory: state.isFromHistory || false
                };
            }
            return null;
        } catch (error) {
            console.error('[存储信息] 获取存储信息时出错:', error);
            return null;
        }
    };
    
    // 暴露历史记录页面检查函数
    window.isFromHistoryPage = function() {
        return window.isFromHistoryPage || false;
    };
    
    // 检查对话是否有效的函数
    async function validateConversation(conversationId) {
        try {
            const response = await fetch(`/api/chat/conversation/${conversationId}`);
            const data = await response.json();
            return data && data.success && data.conversation;
        } catch (error) {
            console.error('[对话验证] 验证对话时出错:', error);
            return false;
        }
    }
    
    // 页面卸载时保存状态
    window.addEventListener('beforeunload', function() {
        saveChatState();
    });
    
    // 页面可见性变化时保存状态
    document.addEventListener('visibilitychange', function() {
        if (document.visibilityState === 'hidden') {
            saveChatState();
        }
    });
    
    // 提取竞赛名称
    function extractCompetitionName(text) {
        // 更严格的匹配规则：必须包含"竞赛名称："前缀
        const pattern = /竞赛名称[:：]\s*(.+?)\s*(?:比赛|竞赛)?\s*$/i;
        
        const m = text.match(pattern);
        if (m && m[1]) {
            let name = m[1].trim()
                .replace(/["""']+/g, '')
                .replace(/[。；;,.、]+$/g, '');
                
            // 去除括号内的内容（包括中文和英文括号）
            name = name.replace(/[（(].*?[）)]/g, '');
            
            // 过滤掉明显不是竞赛名称的文本
            if (name.length >= 2 && name.length <= 30 && 
                !name.includes('适合原因') && 
                !name.includes('竞赛时间') && 
                !name.includes('你是山东大学') &&
                !name.includes('培养方案') &&
                !name.includes('专业核心课程')) {
                return name;
            }
        }
        return null;
    }
    
    // 搜索竞赛数据
    async function searchCompetition(name) {
        if (!name) return null;
        
        // 构建搜索策略
        const strategies = [
            name, // 原始名称
            name.replace(/[（(].*?[）)]/g, '').trim(), // 去除括号内容
            name.replace(/\s+/g, ''), // 去除所有空格
            ...(name.match(/[（(]([A-Z]+)[）)]/) ? [name.match(/[（(]([A-Z]+)[）)]/)[1]] : []), // 括号内英文缩写
            name.replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, '') // 去除标点
        ].filter(s => s && s.length > 1);
        
        console.log('[竞赛搜索] 搜索策略:', strategies);
        
        for (const term of strategies) {
            try {
                const url = `/api/competitions/search?q=${encodeURIComponent(term)}`;
                console.log('[竞赛搜索] 尝试搜索:', term, 'URL:', url);
                
                const resp = await fetch(url, {
                    method: 'GET',
                    headers: {
                        'Content-Type': 'application/json',
                        'Accept': 'application/json'
                    }
                });
                
                if (!resp.ok) {
                    console.warn('[竞赛搜索] 请求失败:', resp.status);
                    continue;
                }
                
                const data = await resp.json();
                console.log('[竞赛搜索] 响应数据:', data);
                
                if (Array.isArray(data) && data.length > 0) {
                    return data.find(c => (c.name || '').trim() === term) || data[0];
                }
            } catch (e) {
                console.error('[竞赛搜索] 搜索错误:', e);
            }
        }
        return null;
    }
    
    // 添加查看详情按钮
    function addDetailButton(element, competition) {
        if (!element || !competition) return;
        
        // 检查是否已经添加过按钮
        if (element.querySelector('.comp-ref-btn')) return;
        
        const button = document.createElement('button');
        button.className = 'comp-ref-btn';
        button.textContent = '查看详情';
        button.style.cssText = `
            margin-left: 8px;
            padding: 4px 8px;
            background: #2A5CAA;
            color: white;
            border: none;
            border-radius: 4px;
            font-size: 12px;
            cursor: pointer;
        `;
        
        // 将竞赛信息保存到按钮的data属性中，用于本地恢复
        button.dataset.competition = JSON.stringify(competition);
        
        button.addEventListener('click', (e) => {
            e.stopPropagation();
            if (typeof window.showCompetitionDetail === 'function') {
                window.showCompetitionDetail(competition);
            }
        });
        
        element.appendChild(button);
        console.log('[按钮添加] 已为竞赛添加按钮:', competition.name);
    }
    
    // 竞赛缓存，避免重复查询
    const competitionCache = new Map();
    
    // 清理函数，在每次新对话开始时调用
    function clearCompetitionCache() {
        competitionCache.clear();
        console.log('[竞赛处理] 已清理竞赛缓存');
    }
    
    // 处理单个p标签的竞赛检索
    async function processParagraphForCompetitions(pElement) {
        if (!pElement || pElement.hasAttribute('data-competition-processed')) return;
        
        try {
            pElement.setAttribute('data-competition-processed', 'processing');
            const text = (pElement.textContent || '').trim();
            
            const name = extractCompetitionName(text);
            if (!name) {
                pElement.removeAttribute('data-competition-processed');
                return;
            }
            
            console.log('[竞赛处理] 提取到竞赛名称:', name);
            
            // 检查缓存
            if (competitionCache.has(name)) {
                const comp = competitionCache.get(name);
                addDetailButton(pElement, comp);
                pElement.setAttribute('data-competition-processed', 'done');
                return;
            }
            
            const comp = await searchCompetition(name);
            if (!comp) {
                pElement.removeAttribute('data-competition-processed');
                return;
            }
            
            // 缓存结果
            competitionCache.set(name, comp);
            addDetailButton(pElement, comp);
            pElement.setAttribute('data-competition-processed', 'done');
            
        } catch (e) {
            console.error('[竞赛处理] 处理错误:', e);
            pElement.removeAttribute('data-competition-processed');
        }
    }
    
    // 处理容器中所有新的p标签
    function processNewParagraphs(container) {
        if (!container) return;
        
        // 只处理未处理的p标签，避免重复处理
        const pElements = container.querySelectorAll('p:not([data-competition-processed])');
        if (pElements.length === 0) return; // 如果没有新的p标签，直接返回
        
        console.log(`[竞赛处理] 发现 ${pElements.length} 个新的p标签`);
        pElements.forEach(p => {
            processParagraphForCompetitions(p);
        });
    }
    
    // 发送消息
    function sendMessage() {
        if (!chatInput || !chatButton || !chatMessages) return;
        
        const message = chatInput.value.trim();
        if (!message) return;
        
        console.log(message)
        // 清理之前的竞赛缓存，开始新对话
        clearCompetitionCache();
        // 添加用户消息
        addMessage(message, 'user');
        chatInput.value = '';
        
        // 保存当前状态（包括对话ID）
        saveChatState();
        
        // 禁用输入和按钮
        if (chatInput) chatInput.disabled = true;
        if (chatButton) {
            chatButton.disabled = true;
            chatButton.textContent = '发送中...';
        }
        
        // 创建AI消息容器（流式显示）
        const aiMessageDiv = addMessage('', 'ai', true);
        let aiResponse = '';
        
        // 获取当前对话ID（可能来自历史对话）
        const conversationId = window.currentConversationId || currentConversationId;
        
        // 包装：带超时与重试的流式请求
        const controller = new AbortController();
        const timeoutMs = 25000; // 25s 无数据认为断流
        let inactivityTimer = null;
        let retries = 0;
        const maxRetries = 3;

        function resetInactivityTimer() {
            if (inactivityTimer) clearTimeout(inactivityTimer);
            inactivityTimer = setTimeout(() => {
                controller.abort();
            }, timeoutMs);
        }

        function startStream() {
            resetInactivityTimer();
            return fetch('/api/ai/chat/stream', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ 
                message: message,
                conversation_id: conversationId
                }),
                signal: controller.signal
            })
        }

        function handleStream(response) {
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            // 检查响应类型
            if (!response.body) {
                throw new Error('响应体不可读');
            }
            
            const reader = response.body.getReader();
            const decoder = new TextDecoder();
            let buffer = '';
            
            function processStream() {
                return reader.read().then(({ done, value }) => {
                    if (done) {
                        if (aiResponse.trim()) {
                            updateMessage(aiMessageDiv, aiResponse.trim());
                            // 确保DOM更新完成后处理竞赛名称
                            setTimeout(() => {
                                console.log('[流式处理] 开始处理竞赛名称');
                                // 使用新的竞赛匹配器处理现有内容
                                if (globalCompetitionMatcher) {
                                    globalCompetitionMatcher.queueElement(aiMessageDiv);
                                    globalCompetitionMatcher.debounceProcess();
                                } else {
                                    // 如果没有全局竞赛匹配器，使用本地处理
                                    processNewParagraphs(aiMessageDiv);
                                }
                            }, 100); // 适当延迟确保DOM渲染完成
                        }
                        return;
                    }
                    
                    // 解码数据块
                    const chunk = decoder.decode(value, { stream: true });
                    buffer += chunk;
                    // SSE通常以\n\n分隔，这里按行解析，保留不完整行在buffer中
                    const parts = buffer.split('\n');
                    // 最后一段可能是不完整的，先保留
                    buffer = parts.pop();
                    
                    for (const line of parts) {
                        if (line.startsWith('data: ')) {
                            try {
                                const dataText = line.slice(6).trim();
                                if (dataText === '') continue;
                                
                                const data = JSON.parse(dataText);
                                console.log('收到流式数据:', data); // 调试日志
                                
                                if (data.type === 'chunk' && data.content) {
                                    // 处理流式内容块
                                    aiResponse += data.content;
                                    // 流式更新时也进行增强，确保早段文本也能被替换
                                    updateMessage(aiMessageDiv, aiResponse);
                                    
                                    // 在每次更新后处理新渲染的p标签，但使用防抖机制
                                    if (aiMessageDiv._competitionProcessTimer) {
                                        clearTimeout(aiMessageDiv._competitionProcessTimer);
                                    }
                                    aiMessageDiv._competitionProcessTimer = setTimeout(() => {
                                        processNewParagraphs(aiMessageDiv);
                                    }, 200); // 增加延迟，减少频繁处理
                                    
                                    resetInactivityTimer();
                                } else if (data.type === 'done') {
                                    // 对话完成
                                    if (data.conversation_id) {
                                        currentConversationId = data.conversation_id;
                                        window.currentConversationId = data.conversation_id; // 同步到全局变量
                                        // 保存状态（包括新的对话ID）
                                        saveChatState();
                                    }
                                    console.log('流式响应完成，总长度:', aiResponse.length);
                                    return; // 结束流式处理
                                } else if (data.type === 'error') {
                                    // 处理错误
                                    console.error('收到错误响应:', data.content);
                                    updateMessage(aiMessageDiv, data.content || '抱歉，智能助手出现错误。');
                                    return; // 结束流式处理
                                }
                            } catch (e) {
                                console.error('解析SSE数据失败:', e, '原始数据:', line);
                                continue;
                            }
                        }
                    }
                    
                    // 继续读取下一个数据块
                    return processStream();
                });
            }
            
            // 开始处理流式响应
            return processStream();
        }

        function fallbackNonStream() {
            // 回退非流式接口，至少给出完整回答
            return fetch('/api/ai/chat', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ message: message, conversation_id: conversationId })
            })
            .then(r => r.json())
            .then(data => {
                if (data && data.success && data.response) {
                    if (data.conversation_id) {
                        currentConversationId = data.conversation_id;
                        window.currentConversationId = data.conversation_id;
                        // 保存状态（包括新的对话ID）
                        saveChatState();
                    }
                    aiResponse = data.response;
                    updateMessage(aiMessageDiv, aiResponse.trim());
                    
                    // 非流式响应完成后也处理竞赛名称
                    setTimeout(() => {
                        processNewParagraphs(aiMessageDiv);
                    }, 100);
                } else {
                    updateMessage(aiMessageDiv, (data && data.error) || '抱歉，连接出现问题，请稍后再试。');
                }
            });
        }

        function runWithRetry() {
            return startStream()
            .then(handleStream)
            .catch(err => {
                console.warn('流式连接错误/中断:', err);
                if (retries < maxRetries) {
                    // 允许最多3次重试，包含指数退避
                    retries++;
                    // 重置控制器与定时器
                    if (inactivityTimer) clearTimeout(inactivityTimer);
                    const delay = 600 * Math.pow(2, retries - 1); // 600ms, 1200ms, 2400ms
                    return new Promise(res => setTimeout(res, delay)).then(() => {
                        return runWithRetry();
                    });
                }
                // 多次失败则回退
                return fallbackNonStream();
            })
            .finally(() => {
                if (inactivityTimer) clearTimeout(inactivityTimer);
            });
        }

        runWithRetry()
        .catch(error => {
            console.error('AI聊天错误:', error);
            updateMessage(aiMessageDiv, '抱歉，连接出现问题，请稍后再试。');
        })
        .finally(() => {
            // 恢复输入和按钮
            if (chatInput) chatInput.disabled = false;
            if (chatButton) {
                chatButton.disabled = false;
                chatButton.textContent = '发送';
            }
        });
    }
    
    // 添加消息到聊天窗口
    function addMessage(text, type, isStreaming = false) {
        if (!chatMessages) return;
        
        const messageDiv = document.createElement('div');
        messageDiv.className = `message ${type}-message ${isStreaming ? 'streaming' : ''}`;
        
        // 如果是AI消息且包含Markdown内容，则渲染Markdown
        if (type === 'ai' && text && (text.includes('```') || text.includes('**') || text.includes('*') || text.includes('#') || text.includes('- ') || text.includes('1. ') || text.includes('[') || text.includes('`')) && window.marked) {
            // 预处理文本，确保换行符被正确处理
            const processedText = text.replace(/\n/g, '\n\n');
            messageDiv.innerHTML = marked.parse(processedText);
            // 不在这里处理竞赛名称，只在流完全结束后处理一次
        } else {
            messageDiv.textContent = text;
        }
        
        chatMessages.appendChild(messageDiv);
        chatMessages.scrollTop = chatMessages.scrollHeight;
        
        return messageDiv;
    }
    
    // 更新消息内容函数中的修改部分
    function updateMessage(messageDiv, text) {
        if (messageDiv) {
            // 如果是AI消息且包含Markdown内容，则渲染Markdown
            if (messageDiv.classList.contains('ai-message') && text && (text.includes('```') || text.includes('**') || text.includes('*') || text.includes('#') || text.includes('- ') || text.includes('1. ') || text.includes('[') || text.includes('`')) && window.marked) {
                // 预处理文本，确保换行符被正确处理
                const processedText = text.replace(/\n/g, '\n\n');
                messageDiv.innerHTML = marked.parse(processedText);
                // 不在这里处理竞赛名称，只在流完全结束后处理一次
            } else {
                messageDiv.textContent = text;
            }
            messageDiv.classList.remove('streaming');
            
            // 滚动到底部
            if (chatMessages) {
                chatMessages.scrollTop = chatMessages.scrollHeight;
            }
        }
    }
    
    // 绑定发送按钮和回车键
    if (chatButton) {
        chatButton.addEventListener('click', sendMessage);
    }
    
    if (chatInput) {
        chatInput.addEventListener('keypress', function(e) {
            if (e.key === 'Enter') {
                sendMessage();
            }
        });
    }
}

// 将函数暴露到全局作用域，以便其他模块调用
window.initAIChat = initAIChat;
